1. Field of the Invention
This invention relates to computer networks and communication management, and to the establishment of communication between various users and/or software applications.
2. Background Discussion
The term xe2x80x9cThe Information Superhighwayxe2x80x9d is commonly thought of as an extension of the Internet, a network linking hundreds of thousands of computer systems together and communicating via a standard protocol.
A computer network is simply a collection of autonomous computers connected together to permit sharing of hardware and software resources, and to increase overall reliability. The qualifying term xe2x80x9clocal areaxe2x80x9d is usually applied to computer networks in which the computers are located in a single building or in nearby buildings, such as on a college campus or at a single corporate site. When the computers are further apart the term xe2x80x9cwide area networkxe2x80x9d may be used.
As computer networks have developed, various approaches have been used in the choice of communication medium, network topology, message format, protocols for channel access, and so forth. Some of these approaches have emerged as de facto standards, but there is still no single standard for network communication. The Internet is a continually evolving collection of networks, including Arpanet, NSFnet, regional networks such as NYsernet, local networks at a number of university and research institutions, a number of military networks, and increasing, various commercial networks. The protocols generally referred to as TCP/IP were originally developed for use through Arpanet and have subsequently become widely used in the industry. The protocols provide a set of services that permit users to communicate with each other across the entire Internet.
A model for network architectures has been proposed and widely accepted. It is known as the International Standards Organization (ISO) Open Systems Interconnection (OSI) reference model. (See FIG. 10.) The OSI reference model is not itself a network architecture. Rather it specifies a hierarchy of protocol layers and defines the function of each layer in the network. Each layer in one computer of the network carries on a conversation with the corresponding layer in another computer with which communication is taking place, in accordance with a protocol defining the rules of this communication. In reality, information is transferred down from layer to layer in one computer, then through the channel medium and back up the successive layers of the other computer. However, for purposes of design of the various layers and understanding their functions, it is easier to consider each of the layers as communicating with its counterpart at the same level, in a xe2x80x9chorizontalxe2x80x9d direction. (See, e.g. The TCP/IP Companion, by Martin R. Arick, Boston: QED Publishing Group 1993, and U.S. Pat. No. 5,159,592. These, and all patents and publications referenced herein, are hereby incorporated by reference.)
As shown in FIG. 10, the lowest layer defined by the OSI model is called the xe2x80x9cphysical layer,xe2x80x9d and is concerned with transmitting raw data bits over the communication channel. Design of the physical layer involves issues of electrical, mechanical or optical engineering, depending on the medium used for the communication channel. The second layer, next above the physical layer, is called the xe2x80x9cdata linkxe2x80x9d layer. The main task of the data link layer is to transform the physical layer, which interfaces directly with the channel medium, into a communication link that appears error-free to the next layer above, known as the network layer. The data link layer performs such functions as structuring data into packets or frames, and attaching control information to the packets or frames, such as checksums for error detection, and packet numbers.
The Internet Protocol (IP) is implemented in the third layer of the OSI reference model, the xe2x80x9cnetwork layer,xe2x80x9d and provides a basic service to TCP: delivering datagrams to their destinations. TCP simply hands IP a datagram with an intended destination; IP is unaware of any relationship between successive datagrams, and merely handles routing of each datagram to its destination. If the destination is a station connected to a different LAN, the IP makes use of routers to forward the message.
The basic function of the Transmission Control Protocol (TCP) is to make sure that commands and messages from an application protocol, such as computer mail, are sent to their desired destinations. TCP keeps track of what is sent, and retransmits anything that does not get to its destination correctly. If any message is too long to be sent as one xe2x80x9cdatagram,xe2x80x9d TCP will split it into multiple datagrams and makes sure that they all arrive correctly and are reassembled for the application program at the receiving end. Since these functions are needed for many applications, they are collected into a separate protocol (TCP) rather than being part of each application. TCP is implemented in the xe2x80x9ctransport layer,xe2x80x9d namely the fourth layer of the OSI reference model.
Except as otherwise is evident from the context, the various functions of the present invention reside above the transport layer of the OSI model. The present invention may be used in conjunction with TCP/IP at the transport and network layers, as well as with any other protocol that may be selected.
As shown in FIG. 10, the OSI model provides for three layers above the transport layer, namely a xe2x80x9csession layer,xe2x80x9d a xe2x80x9cpresentation layer,xe2x80x9d and an xe2x80x9capplication layer,xe2x80x9d but in the Internet these theoretical xe2x80x9clayersxe2x80x9d are undifferentiated and generally are all handled by application software. The present invention provides for session control and for communicating with applications programs. Thus the present invention may be described in accordance with the OSI theoretical model as operating at the session layer and application layers.
xe2x80x9cConnectivityxe2x80x9d and xe2x80x9cconvergencexe2x80x9d have been used to describe two aspects of the communications and computing revolution taking place. In 1994, technology provides to communicate by telephone, pager, fax, email, cellular phone, and broadcast audio and video. However, to use these communication services, you have to employ a telephone number, beeper number, pager number, fax number, cellular number, and each of many email IDs, radio stations and television channels. The user is confronted with an overabundance of methods providing such physical connectivity, one which will only grow in the future.
The types of physical connections are provided by various systems including the Regional Bell Operating Companies, the Long Distance Carriers, the Cellular Networks, and others providing signal-based or wireless communications. The Cable Television Industry provides connectivity for video signals and increasingly other services.
The present invention provides a virtual network, sitting xe2x80x9cabovexe2x80x9d the physical connectivity and thereby providing the administrative controls necessary to link various communication devices via an Access-Method-Independent Exchange. In this sense, the Access-Method-Independent Exchange can be viewed as providing the logical connectivity required. In accordance with the present invention, connectivity is provided by a series of communication primitives designed to work with each of the specific communication devices in use. As new communication devices are developed, primitives can be added to the Access-Method-Independent Exchange to support these new devices without changing the application source code. When viewed in accordance with the OSI model, the communication primitives operate at the level of the transport layer, and, to the extent appropriate, at the network layer, and in some instances down to the data link layer, and occasionally as needed, the physical layer.
Using the Access-Method-Independent Exchange of the present invention, anybody can provide a service. Similarly, anybody can be a client of a service. A service can even be a client of another service. This is because every user and every service is identified by a unique communication identifier. In accordance with the present invention, various communication points are connected together to form a communication link.
The aforesaid identifiers are assigned to the user, or service provider, during their subscription process. For service providers, additional information must be provided and added to the Thread Directory Service. This information includes the required physical connectivity to reach the service.
When users want to access the Access-Method-Independent Exchange, they simply supply Exchange with their unique identifiers. The Binding Service validates each user and permits access to the Exchange. The user may then connect to any registered service by simply calling the service""s communication identifier. Of course, if they are unfamiliar with the service providers communication identifier, they can request assistance through the Thread Directory Service. The Thread Directory Service provides a listing of available services grouped by relationship. The user can search for keywords, titles, or other information such as service fees. Ultimately, the user can request to gain access to the service.
The Access-Method-Independent Exchange is not limited to servicing a particular geographic area and hence can easily work with foreign countries. The Access-Method-Independent Exchange includes the ability to provide voice or data message processing.
At the core of the technology is the Thread Communication Service (TCS), a software utility used to administer the dynamic communications between computer processes executing on a local computer, or, on a remote system. Two versions of the TCS have been implemented: one for intraprocess communications and a second for interprocess communications. The intraprocess version of the TCS is used for a single application process with multiple threads of control. The interprocess version of the TCS provides the administration of communications between processes executing in disjoint address spaces on a local, or remote computer system.
In the TCS everything is viewed as either being a communication primitive, or, a communication point. The communication primitives are the low-level mechanisms used to provide the physical communication between various processes. The processes participating in the communication are referred to as communication points. Two or more communication points are connected by a communication link using the communication primitives.
The communication primitives are built using the underlying computer operating system intraprocess and interprocess communication facilities and thus are operating-system-specific. On one operating system there may be, for example, five communication primitives supported, while another operating system may support twenty. A communication primitive generally must provide for several operations to be applied such as:
Create: The ability to create an instance of the primitive
Destroy: The ability to destroy an instance of the primitive
Send: The ability to send data to the primitive
Receive: The ability to receive data from the primitive
Cycle: Send a default and receive default messages to/from the primitive
Connect: Primitive specific connection function
Disconnect: Primitive specific disconnection function
Suspend: Primitive specific suspension function
Resume: Primitive specific resumption function
Communication primitives are registered with the Thread Communication Service for the specific operating system the TCS is executing on. The name, the location, and certain characteristics describing the communication primitive are retained by the TCS for subsequent use. In this context, the communication primitives become a reusable asset, needing to be developed and tested only one time.
Each communication primitive has a shared object, referred to as the communication primitive object, describing the location of the various operations to be applied when using this primitive type. All primitives have the same communication primitive object structure. The TCS will load the communication primitive object at runtime only when requested for use by a communication point.
In a sense, the communication primitive can be thought of as analogous to the physical connection of a telephone on a phone network. A twisted pair telephone would use one primitive while a cellular telephone would use a different primitive.
A process can register zero or more communication points with the TCS. Each point is said to describe a service. Note, however, that a service can be a client of a different service, or a client of itself. The registration process notifies the TCS as to the name and location of the service, the default primitive to use for communicating to the service, and the default primitive to use when receiving messages from the service.
The registration process also identifies certain characteristics of the communication point. These characteristics include system-dependent information, implementation-dependent information, and usage-dependent information. The characteristics include:
Scope: Determines if service executes as a sibling thread, or in separate address space.
Stack: Required stack size
Idle: If service is to be idle on non-connects
Maxmsg: Maximum number of pending messages prior to suspension
Minmsg: Minimum number of pending messages at which service is resumed
Restart: Service is restartable
Termination: Method for terminating the service
Discarded: Method for discarding unwanted messages
The registered communication points are then retained by the TCS for subsequent use. When a communication point has been registered, a process can request to be connected to the service.
Using the telephone model example, a communication point is the equivalent of a destination telephone. That is, you can call an individual only by knowing the attributes describing that individual, such as a telephone number. The registered characteristics would be similar to your name and address being entered into the phone book. The TCS calls the TDS, if requested, to record the registered communication point in the TDS.
When a process is executing, it may request the TCS to connect it to a communication point. For the intraprocess communication version of the TCS, the service executes as a separate thread of control. In the interprocess communication version of the TCS, the service executes as a separate process.
There are several modifications permitted. First, when a communication point is registered, the registering process can identify the communication point as a public point. As such, only one instance of the service needs to be executing at any time. All processes requesting to use this point will share the same primitive. Alternatively, a service can be registered as a private service, in which case each process requesting communication to the service will be connected to their own instance of the service. Finally, when a service is initially registered, a maximum number of connection points can be preset. When this limit is reached, then all new processes requesting access to the service will be denied, until such time as the number of current instantiations of the service falls below the threshold.
A single process can be connected to multiple services simultaneously. This can be accomplished through a single connection, or, though multiple connections established by the process with the various services. In the former case, each time the process sends data, the data is actually sent to all services using the communication link. In the latter instance, only a single destination is connected to the communication link.
Again, using the telephone model as an example, this is equivalent to your calling a business associate on your telephone system. While connected, you can put the call on hold and dial another associate, or you can conference the associate in on the same call.
On systems supporting multiple threads of control within a single process address space, the TCS uses a special communication point called the intra.sub.xe2x80x94p communication point to execute commands on behalf of the TCS within that address space. That is to say, when the application process makes its initial request to the TCS, the intra.sub.xe2x80x94p communication point will bootstrap itself as a communication point within the application process address space. The TCS then issues specific commands to the intra.sub.xe2x80x94p communication point who executes these commands on behalf of the TCS. The use of the intra.sub.xe2x80x94p communication point is essential to permit intraprocess communication points while supporting interprocess communication points at the same time.
When an application makes a request to connect with a registered communication point, and that point must execute as a separate thread of control within the address space of the requesting process, then the TCS must have a method to satisfy the request. Since the TCS itself is executing in a different address space, it needs a worker thread executing within the requesting process""s address space to spawn the requested communication point thread on its behalf.
The TCS also provides a method for a intraprocess communication point to be. treated as an interprocess communication point. When an application process makes a request to use an intraprocess communication point as an interprocess communication point, the TCS will execute a generic front end loader to initialize the address space of the new process, and then invokes the specific thread requested in that address space.
Once connected, a process can send messages to a service. The primitive to send this message must accept the message, the size of the message, and the destination. Similarly, a process can request to receive a message from a service. In receiving the message, the process must identify the service it is to receive the message from, the maximum length of a message it can consume, and the actual size of the message returned.
Note that from the point of view of the application process, there is no need to be aware of the underlying physical primitive in use. Instead, the application sees that a Thread Communication Link is provided and need not deal with how it is provided.
A process can request the TCS to disconnect it from a particular service. When this happens, the service can be terminate by the TCS if this was the only process connected to it. Otherwise, the service remains executing.
In the TCS model, a special communication point can be created to monitor a communication device available to the computer system. This communication point acts as the conduit to send messages to, and receive messages from the communication device. The primitive used for this communication point wraps the identifier of the sending process, along with the identifier of the receiving process, around the message prior to sending the data out on the communication device. Similarly, when this communication point receives a message from the communication device, it unwraps the message to determine the process that the message is to be sent to. In this sense, the communication point is the conduit for communications with external systems.
When a communication point is registered, the communication point may have a specific communication primitive required to either send or receive message. This poses a challenge for another communication point to connect if the requesting communication point requires a different communication primitive. When this happens, the TCS will search for a broker communication point which can convert the messages from the first primitive type to the second primitive type. The broker service, if necessary, will be inserted between the requesting communication point and the requested service communication point.
In the TCS model, processes are nothing more than communication points. Application programs residing on a disk are also viewed as communication points (albeit the application program must be started for execution by the TCS). This powerful model enables application software development which may effectively commoditize software.
The Thread Directory Service is an extension of the Thread Communication Service offering persistence to the registered communication primitives and registered communication points. When a communication point is registered with the TDS, it is assigned a unique communication identifier. Numerous additional characteristics of the service can be registered within the TDS such as:
1. Textual description of the type of service
2. Sending communication primitive and receiving communication primitive
3. Communication mechanism used in establishing this service
4. Location of the service
5. Input types understood by the service
6. Output types generated by the service
7. Keyword search list used to locate this service entry
8. Token describing if the execution of the service can be started
9. Token describing the data representation in communication with the service, i.e. binary, ASCII, etc.
10. Token describing if the execution of the service must have previously been started
11. Token describing if Thread Communication Identifier is listed or unlisted
12. Token describing if a public connection to the service can be used
13. Token describing if a private connection to the service can be used
14. Token describing if a public connection is mandatory
15. Token describing if a private connection is mandatory
16. Token describing if the service is a component of a larger service
17. Shell actions to execute in initializing this service
18. The maximum number of concurrent communications
19. Licensing information
20. Other general user information
21. Link to additional Services required in using this service
22. Series of status information components including but not limited to security privileges and owner information.
23. Series of additional information components used for future enhancements
24. Thread Communication Identifier
25. Secondary Thread Service Directory
26. Usage Fee
27. Directory Service Fees
Of the foregoing, items 2 and 4 are essential; the others are optional, though desirable.
A process can request information from the Thread Directory Service specifying the desired search criteria. This is similar to dialing 411 and requesting a telephone number for an individual based on their name and street address. Each TDS has its own unique identifier. The registered communication points are assigned unique communication identifiers based on the TDS""s identifier. Thus, communication points are fixed in the universe in this sense.
When the Thread Communication Service works in conjunction with the Thread Directory Service, all communication points to be connected are located via their communication identifiers.
When a connection is requested to a particular communication point, the requesting process specifies the unique communication identifier of the desired service. The TCS causes the identifier to be looked up in the TDS to determine how to connect to the service and then provides the actual connections.
To minimize the message flow, a Thread Communication Switching Service is provided as a special instance of a communication point. It accepts multiple communication links redirecting the communications from one communication point to the appropriate destination communication point. As shown in FIGS. 1 to 4, a TCSS can communicate with communication points, or, to another TCSS.
Dynamic Configuration Management is a rule-based system for specifying components of software to use in constructing a Dynamically Configured Application Program. The components of software are loaded according to the specified rules and are subsequently executed.
The Application Process constructs the Dynamically Configured Application Program in the Dynamic Configuration Management (DCM) by specifying zero or more RULES identifying the components of the Dynamically Configured Application Program, the interactions between these components, the policy for evaluating these components, the order of evaluation of these components, and a method for satisfying the RULE. The Application Process can specify zero or more data files referred to as Virtual Program Rules Files containing RULES for the Dynamically Configured Application Program. In this sense, the Application Process provides the blueprint for constructing the Dynamically Configured Application Program.
The specification of a RULE includes the following information, although additional information may be incorporated by the implementation:
1. A unique alphanumeric name to identify the RULE
2. A DCM operator denoting the policy for evaluating the RULE
3. Zero or more Prerequisite RULES
4. Zero or more Attributes describing characteristics of the RULE
5. A method (possibly given as NULL) for satisfying the RULE
There are two classifications of RULES supported by the DCM given as Reserved Rules and Universal Rules. The Reserved Rules have special meaning to the DCM. The Universal Rules are specified by the Application Process. In either case, however, the Rules contain the minimum information described above.
A series of Reserved Rules, referred to as the Flow Rules, provide the framework for executing the Dynamically Configured Application Program. Whenever a Dynamically Configured Application Program is to be executed, the DCM begins by evaluating the Flow Rules. All other actions are derived as a result thereof. The Flow RULES include:
1. DCMINIT RULE
2. APINIT RULE
3. MAIN RULE
4. APDONE RULE
5. DCMDONE RULE
Note, however, that additional Flow Rules may be incorporated by the implementation.
A Dynamically Configured Application Program is therefore constructed by specifying Universal Rules as Prerequisites Rules of the Flow Rules. In evaluating a Flow Rule, the DCM will ensure that all Prerequisite Rules of the Flow Rule are evaluated first.
In evaluating a RULE, the DCM views the RULE name as the current rule. The evaluation process is such that the DCM will first evaluate all Prerequisite Rules of the current rule. Thus, a Prerequisite Rule becomes the current rule and the evaluation continues with its Prerequisite Rules.
When the current rule has no Prerequisite Rules listed, and the current rule has never been evaluated, then the DCM will execute the method for this rule. After executing the method for the current rule, the DCM attaches a time stamp value denoting when the current rule was evaluated.
When the current rule has one or more Prerequisite Rules, then the DCM compares the time stamp value of the current rule with that of its Prerequisite Rules. If the time stamp value of the current rule is older than the time stamp value of its Prerequisite Rules, then the current rule""s method is executed to satisfy the rule and the time stamp value of the current rule is updated to denote when the current rule was evaluated. Otherwise, the current rule""s time stamp value remains unchanged and the method is not executed.
After evaluating the last Flow Rule of the Dynamically Configured Application Program, the DCM considers the application as having completed and returns control back to the initial Application Process.
Initially when a RULE is specified, the DCM makes no assumptions as to what the RULE name represents. During the evaluation of the RULE, the DCM associates the RULE name with an entity understood by the DCM. This is called the binding process. The list of entities understood by the DCM and their corresponding interpretation by the DCM are provided during the initialization of the DCM. In this sense, the list of entities can be modified and updated over time based on market demand for new entities and their interpretations.
The binding of the RULE name to an entity understood by the DCM is determined by the RULE""s attributes. In this sense, the Application Process can specify how the RULE is to be interpreted by the DCM.
Through the use of this method, Minor Services for an Application Service can be designed, implemented, tested, and distributed independently of the corresponding Application Program. The end-user can therefore purchase and install only those Minor Services of interest. When the Application Program is to be executed, the resulting Application Process will dynamically configure itself to provide the available Minor Services.
The advantage to the computer industry is that the Minor Services, for example, can be designed after the Application Program and sold individually to the end user. The implications are that:
1) the base Application Program need not be altered to support these additional Minor Services
2) since the end-user is purchasing only those Minor Services of interest, the end user does not have to provide additional media storage capacity to support unwanted Minor Services
3) additional Minor Services can be designed, implemented, tested, and installed after the base Application Program thus providing:
a) the designer of the Application Program the ability to design, implement, and test additional Minor Services based on new market demands without changing the existing base Application Program
b) the ability to design, implement, and test additional Minor Services specific to an individual customer without effecting other customers. In this sense, all customers would have the exact same base Application Program, but potentially different installed Minor Services
4) the development of additional Minor Services can be thoroughly tested as smaller units when compared to the approach used today in which a new, monolithic representation of the Application Program must be tested. The advantage herein is that the computational resources required to develop the software are decreased, the cost of testing is decreased, and the Minor Services can be delivered to the market in a shorter time interval.
The Configurable Application Program Service provides a method to dynamically reconfigure an application process. Through the CAPS, a communication point can be dynamically replaced by another communication point. This is important for real-time systems in which you would not want to terminate the application process to replace a defective module.
The Application Process uses the Configuration Administrator Minor Service to administer zero or more components of software from shared libraries. Each component is said to offer a Minor Service. The specifications for the administration of the Minor Services can be provided directly by the Application Service, or, indirectly through a data store monitored by the Configuration Administrator. These specifications can instruct the Configuration Administrator Minor Service to perform the desired operation immediately, at a predefined time (which may be an interval), or, as a result of some event which is later communicated to the Configuration Administrator Minor Service.
The Configuration Administrator Minor Service provides the following operations:
1. Locates specified Minor Services
2. Loads specified Minor Services
3. Executes specified Minor Services
4. Establishes communication channel with the specified Minor Service.
5. Suspends execution of specified Minor Services
6. Resumes execution of specified Minor Services
7. Replaces specified Minor Service with a new Minor Service rerouting communication channels as appropriate
8. Unloads specified Minor Service
9. Provides for manual state retention between replaceable Minor Services
10. Notification
Note that the Configuration Administrator Minor Service operations can be specified to occur at set time intervals; at predefined time periods; as a result of external events; or, as a result of internal events. Events, in this context are registered with the Configuration Administrator Minor Service to denote their occurrence.
The advantage is that an Application Program can be constructed and executed and subsequently reconfigured to take advantage of newly installed minor software services while the Application Process is executing. The implications of such a system are that:
1. Mission-critical Application Programs which require 24 hour, 365 days a year execution can be reconfigured without terminating execution of the existing Application Process.
2. An Application Process can be reconfigured without terminating that Application Process which would otherwise cause the Application Process to lose all data currently held in Random Access Memory
3. An Application Process which requires a significant initialization sequence does not need to be terminated to install new minor software services. Instead, the Application Process can be reconfigured on demand.
4. New software services can be designed, implemented, and tested using an existing Application Process such that the new services can be de-installed if found in fault without disrupting the existing Application Process.
5. Application Processes which monitor real-time events can be dynamically reconfigured to adjust to those real-time events without terminating the existing Application Process.
6. Diagnostic Minor Services can be configured into an existing Application Process for administrative, diagnostic, or statistical analysis and subsequently removed without affecting the existing Application Process.